home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1993 July / InfoMagic USENET CD-ROM July 1993.ISO / sources / unix / volume4 / quickplot / part2 < prev    next >
Encoding:
Internet Message Format  |  1986-11-30  |  54.1 KB
  1. Subject: lplot and quickplot (Part 2 of 2)
  2. From: Duane Hesser <talcott!seismo!hplsla!tikal!sysad>
  3. Newsgroups: mod.sources
  4. Approved: jpn@panda.UUCP
  5.  
  6. Mod.sources:  Volume 4, Issue 94
  7. Submitted by: Duane Hesser <seismo!hplsla!tikal!sysad>
  8.  
  9. #! /bin/sh
  10. # This is a shell archive, meaning:
  11. # 1. Remove everything above the #! /bin/sh line.
  12. # 2. Save the resulting text in a file.
  13. # 3. Execute the file with /bin/sh (not csh) to create the files:
  14. #    Makefile
  15. #    Makefile.lplot
  16. #    Makefile.quick
  17. #    alpha_plot.c
  18. #    functions.c
  19. #    global.c
  20. #    iobuf.c
  21. #    lplot.c
  22. #    read_stream.c
  23. #    defs.h
  24. #    extern.h
  25. #    io.h
  26. #    testprogs.d
  27. # This archive created: Fri May  2 18:21:02 1986
  28. export PATH; PATH=/bin:$PATH
  29. echo shar: extracting "'Makefile'" '(1452 characters)'
  30. if test -f 'Makefile'
  31. then
  32.     echo shar: will not over-write existing file "'Makefile'"
  33. else
  34. cat << \SHAR_EOF > 'Makefile'
  35. # 
  36. # $Header: Makefile,v $
  37. # 
  38. # $Log: Makefile,v $
  39. # 
  40. # 
  41.  
  42. BIN=/usr/public/bin
  43. MAN=/usr/man/manp
  44.  
  45. nothing:
  46.     @echo 'Use:'
  47.     @echo 'make all             to update lplot and quickplot'
  48.     @echo 'make new             to make both from scratch'
  49.     @echo 'make clean           to remove .o files'
  50.     @echo 'make bclean          to remove binaries and .o files'
  51.     @echo 'make lplot           to make only lplot'
  52.     @echo 'make quickplot       to make only quickplot'
  53.     @echo 'make install         to update and install both'
  54.     @echo 'make install_l       to update and install lplot'
  55.     @echo 'make install_q       to update and install quickplot'
  56.     @echo 'make install.man     to update and install man pages'
  57.  
  58. all:    lplot quickplot 
  59.  
  60. new:    bclean all
  61.  
  62. lplot: MAKINGLPLOT    FORCE
  63.     make -f Makefile.lplot
  64.  
  65. quickplot: MAKINGQUICK    FORCE
  66.     make -f Makefile.quick
  67.  
  68. FORCE:
  69.  
  70. bclean:
  71.     -rm -f *.o quickplot lplot LQPLOT.*
  72.  
  73. clean:
  74.     -rm -f *.o  LQPLOT.*
  75.  
  76. copy:
  77.     cpr -n -s defs.h global.c extern.h io.h lplot.c read_stream.c \
  78.     functions.c iobuf.c  alpha_plot.c | lprn -E4
  79.  
  80. install: install_l install_q
  81.  
  82. install_l: lplot 
  83.     -rm -f $(BIN)/lplot $(BIN)/rlplot $(BIN)/quickplot
  84.     install -s lplot $(BIN)
  85.     ln $(BIN)/lplot $(BIN)/rlplot
  86.  
  87. install_q: quickplot
  88.     install -s quickplot $(BIN)
  89.  
  90. install.man:
  91.     cp lplot.p quickplot.p $(MAN)
  92.     man lplot > /dev/null
  93.     man quickplot > /dev/null
  94.  
  95. MAKINGLPLOT:
  96.     -rm -f MAKINGQUICK *.o
  97.     touch MAKINGLPLOT
  98.  
  99. MAKINGQUICK:
  100.     -rm -f MAKINGLPLOT *.o
  101.     touch MAKINGQUICK
  102.  
  103. SHAR_EOF
  104. if test 1452 -ne "`wc -c < 'Makefile'`"
  105. then
  106.     echo shar: error transmitting "'Makefile'" '(should have been 1452 characters)'
  107. fi
  108. fi
  109. echo shar: extracting "'Makefile.lplot'" '(729 characters)'
  110. if test -f 'Makefile.lplot'
  111. then
  112.     echo shar: will not over-write existing file "'Makefile.lplot'"
  113. else
  114. cat << \SHAR_EOF > 'Makefile.lplot'
  115. # 
  116. # $Header: Makefile.lplot,v $
  117. # 
  118. # $Log: Makefile.lplot,v $
  119. # 
  120. # 
  121.  
  122. DEFINES=-DDEBUG -DBIGENDIAN
  123. CFLAGS = -O $(DEFINES)
  124. #CFLAGS = -pg $(DEFINES)
  125.  
  126. lplot:    global.o lplot.o read_stream.o \
  127.         functions.o iobuf.o alpha_plot.o
  128.         cc -o lplot $(CFLAGS) global.o lplot.o \
  129.         read_stream.o functions.o iobuf.o \
  130.         alpha_plot.o -lm 
  131.  
  132. clean:
  133.         rm -f *.o
  134.  
  135. copy:
  136.         cpr -n -s defs.h global.c extern.h io.h \
  137.         lplot.c read_stream.c functions.c iobuf.c \
  138.         alpha_plot.c | lprn
  139.  
  140. lint:
  141.         lint -ph $(DEFINES) global.c lplot.c \
  142.         read_stream.c functions.c iobuf.c \
  143.         alpha_plot.c
  144.  
  145. global.o:    defs.h io.h
  146. lplot.o:    defs.h extern.h io.h
  147. read_stream.o:    defs.h extern.h
  148. functions.o:    defs.h extern.h
  149. iobuf.o:    defs.h extern.h io.h
  150. alpha_plot.o:    extern.h
  151. SHAR_EOF
  152. if test 729 -ne "`wc -c < 'Makefile.lplot'`"
  153. then
  154.     echo shar: error transmitting "'Makefile.lplot'" '(should have been 729 characters)'
  155. fi
  156. fi
  157. echo shar: extracting "'Makefile.quick'" '(679 characters)'
  158. if test -f 'Makefile.quick'
  159. then
  160.     echo shar: will not over-write existing file "'Makefile.quick'"
  161. else
  162. cat << \SHAR_EOF > 'Makefile.quick'
  163. # 
  164. # $Header: Makefile.quick,v $
  165. # 
  166. # $Log: Makefile.quick,v $
  167. # 
  168. # 
  169.  
  170. DEFINES=-DQUICKPLOT -DDEBUG -DBIGENDIAN
  171. CFLAGS = -O $(DEFINES)
  172. #CFLAGS = -pg $(DEFINES)
  173.  
  174. quickplot:    global.o lplot.o read_stream.o functions.o iobuf.o
  175.     cc -o quickplot $(CFLAGS) global.o lplot.o read_stream.o \
  176.         functions.o iobuf.o -lm -ltermcap
  177.  
  178. clean:
  179.     rm -f *.o quickplot lplot
  180.  
  181. copy:
  182.     cpr -n -s defs.h global.c extern.h io.h lplot.c read_stream.c \
  183.     functions.c iobuf.c  | lprn
  184.  
  185. lint:
  186.     lint -ph $(DEFINES) global.c lplot.c read_stream.c \
  187.     functions.c iobuf.c 
  188.  
  189. global.o:    defs.h io.h
  190. lplot.o:    defs.h extern.h io.h
  191. read_stream.o:    defs.h extern.h
  192. functions.o:    defs.h extern.h
  193. iobuf.o:    defs.h extern.h io.h
  194. SHAR_EOF
  195. if test 679 -ne "`wc -c < 'Makefile.quick'`"
  196. then
  197.     echo shar: error transmitting "'Makefile.quick'" '(should have been 679 characters)'
  198. fi
  199. fi
  200. echo shar: extracting "'alpha_plot.c'" '(9282 characters)'
  201. if test -f 'alpha_plot.c'
  202. then
  203.     echo shar: will not over-write existing file "'alpha_plot.c'"
  204. else
  205. cat << \SHAR_EOF > 'alpha_plot.c'
  206. /* :set tabstops=4                                                    */
  207. static char *RCSid = "$Header: alpha_plot.c,v 1.1 86/04/20 16:16:28 sysad Exp $";
  208.  
  209. /*
  210.  * $Log:    alpha_plot.c,v $
  211.  * Revision 1.1  86/04/20  16:16:28  sysad
  212.  * Initial distribution version
  213.  * 
  214.  * 
  215.  */
  216.  
  217.  
  218. /* It is the intent of the author that this software may be distributed
  219.  * and used freely, without restriction.  If you make improvements or
  220.  * enhancements, I would appreciate a copy.
  221.  *
  222.  * Duane H. Hesser    Teltone Corporation
  223.  * ....uw-beaver!tikal!sysad
  224.  * ....uw-beaver!tikal!dhh
  225.  */
  226.  
  227. /* Character table for generation of ascii characters.
  228.  * Each row represents one character.  A nine high by eight wide
  229.  * matrix is used, including two descenders.  The first byte of
  230.  * each row is the "width" of the character; the remaining bytes
  231.  * are the bit pattern of the character, starting with the
  232.  * descenders (table[x][3] is the lower left corner of the character,
  233.  * which references the starting location of the character).
  234.  *
  235.  * Characters generated by lplot are rather severely restricted
  236.  * by the low dot density; as a result, labels will usually be
  237.  * "longer" in plotted length than those produced by other filters.
  238.  * The "width" includes the separation of the character from any
  239.  * following character (starting location of current character +
  240.  * width of current character = starting location of following
  241.  * character).  This is used to improve the appearance of labels,
  242.  * and reduce the problem of label size expansion.
  243.  */
  244. #include "extern.h"
  245.  
  246. char table[][10] = {
  247. 5, 0,    0,    0,    0,    0,    0,    0,    0,    0,      /* ' '   */
  248. 6, 0,    0,    040,  0,    040,  040,  040,  040,  040,    /*  '!'  */
  249. 5, 0,    0,    0,    0,    0,    0,    0,    0120, 0120,   /*  '"'  */
  250. 7, 0,    0,    0120, 0120, 0370, 0120, 0370, 0120, 0120,   /*  '#'  */
  251. 9, 0,    0,    020,  0374, 022,  0174, 0220, 0176, 020,    /*  '$'  */
  252. 9, 0,    0,    0204, 0112, 044,  020,  0110, 0244, 0102,   /*  '%'  */
  253. 8, 0,    0,    0144, 0230, 0220, 0250, 0104, 0240, 0100,   /*  '&'  */
  254. 3, 0,    0,    0,    0,    0,    0,    0200, 0100, 0100,   /*  '''  */
  255. 5, 0,    0,    040,  0100, 0200, 0200, 0200, 0100, 040,    /*  '('  */
  256. 5, 0,    0,    0200, 0100, 040,  040,  040,  0100, 0200,   /*  ')'  */
  257. 7, 0,    0,    0250, 0160, 0330, 0160, 0250, 0,    0,      /*  '*'  */
  258. 7, 0,    0,    040,  040,  0370, 040,  040,  0,    0,      /*  '+'  */
  259. 4, 0200, 0100, 0100, 0,    0,    0,    0,    0,    0,      /*  ','  */
  260. 7, 0,    0,    0,    0,    0,    0370, 0,    0,    0,      /*  '-'  */
  261. 3, 0,    0,    0200, 0,    0,    0,    0,    0,    0,      /*  '.'  */
  262. 9, 0,    0,    0200, 0100, 040,  020,  010,  04,   02,     /*  '/'  */
  263. 9, 0,    0,    070,  0104, 0202, 0202, 0202, 0104, 070,    /*  '0'  */
  264. 6, 0,    0,    0160, 0040, 0040, 0040, 0040, 0140, 0040,   /*  '1'  */
  265. 8, 0,    0,    0374, 0200, 0160, 010,  04,   0204, 0170,   /*  '2'  */
  266. 8, 0,    0,    0170, 0204, 04,   070,  04,   0204, 0170,   /*  '3'  */
  267. 8, 0,    0,    010,  010,  0374, 0210, 0110, 050,  010,    /*  '4'  */
  268. 8, 0,    0,    0160, 0210, 04,   010,  0360, 0200, 0370,   /*  '5'  */
  269. 8, 0,    0,    0170, 0204, 0204, 0370, 0100, 040,  020,    /*  '6'  */
  270. 8, 0,    0,    0100, 0100, 0100, 040,  020,  010,  0374,   /*  '7'  */
  271. 9, 0,    0,    070,  0104, 0202, 0104, 070,  0104, 070,    /*  '8'  */
  272. 8, 0,    0,    040,  020,  010,  0170, 0204, 0204, 0170,   /*  '9'  */
  273. 4, 0,    0,    0,    0300, 0,    0,    0300, 0,    0,      /*  ':'  */
  274. 5, 0,    0200, 0100, 0140, 0,    0140, 0,    0,    0,      /*  ';'  */
  275. 6, 0,    0,    020,  040,  0100, 0200, 0100, 040,  020,    /*  '<'  */
  276. 7, 0,    0,    0,    0,    0370, 0,    0370, 0,    0,      /*  '='  */
  277. 6, 0,    0,    0200, 0100, 040,  020,  040,  0100, 0200,   /*  '>'  */
  278. 8, 0,    0,    040,  0,    040,  020,  010,  0204, 0170,   /*  '?'  */
  279. 10,   0, 0,    076,  0100, 0236, 0245, 0231, 0102, 074,    /*  '@'  */
  280. 9, 0,    0,    0202, 0202, 0376, 0202, 0104, 050,  020,    /*  'A'  */
  281. 8, 0,    0,    0370, 0204, 0204, 0370, 0204, 0204, 0370,   /*  'B'  */
  282. 8, 0,    0,    0170, 0204, 0200, 0200, 0200, 0204, 0170,   /*  'C'  */
  283. 8, 0,    0,    0370, 0204, 0204, 0204, 0204, 0204, 0370,   /*  'D'  */
  284. 8, 0,    0,    0374, 0200, 0200, 0360, 0200, 0200, 0374,   /*  'E'  */
  285. 8, 0,    0,    0200, 0200, 0200, 0360, 0200, 0200, 0374,   /*  'F'  */
  286. 8, 0,    0,    0170, 0204, 0204, 0214, 0200, 0204, 0170,   /*  'G'  */
  287. 8, 0,    0,    0204, 0204, 0204, 0374, 0204, 0204, 0204,   /*  'H'  */
  288. 5, 0,    0,    0340, 0100, 0100, 0100, 0100, 0100, 0340,   /*  'I'  */
  289. 7, 0,    0,    0140, 0220, 020,  020,  020,  020,  070,    /*  'J'  */
  290. 8, 0,    0,    0204, 0210, 0220, 0340, 0220, 0210, 0204,   /*  'K'  */
  291. 8, 0,    0,    0374, 0200, 0200, 0200, 0200, 0200, 0200,   /*  'L'  */
  292. 9, 0,    0,    0202, 0202, 0202, 0222, 0252, 0306, 0202,   /*  'M'  */
  293. 9, 0,    0,    0202, 0206, 0212, 0222, 0242, 0302, 0202,   /*  'N'  */
  294. 8, 0,    0,    0170, 0204, 0204, 0204, 0204, 0204, 0170,   /*  'O'  */
  295. 8, 0,    0,    0200, 0200, 0200, 0370, 0204, 0204, 0370,   /*  'P'  */
  296. 8, 0,    0,    064,  0110, 0224, 0204, 0204, 0110, 060,    /*  'Q'  */
  297. 8, 0,    0,    0204, 0210, 0220, 0370, 0204, 0204, 0370,   /*  'R'  */
  298. 8, 0,    0,    0170, 0204, 04,   0170, 0200, 0204, 0170,   /*  'S'  */
  299. 6, 0,    0,    040,  040,  040,  040,  040,  040,  0370,   /*  'T'  */
  300. 9, 0,    0,    070,  0104, 0202, 0202, 0202, 0202, 0202,   /*  'U'  */
  301. 9, 0,    0,    020,  050,  0104, 0202, 0202, 0202, 0202,   /*  'V'  */
  302. 9, 0,    0,    0202, 0306, 0252, 0222, 0202, 0202, 0202,   /*  'W'  */
  303. 9, 0,    0,    0202, 0104, 050,  020,  050,  0104, 0202,   /*  'X'  */
  304. 9, 0,    0,    020,  020,  020,  020,  050,  0104, 0202,   /*  'Y'  */
  305. 8, 0,    0,    0374, 0200, 0100, 040,  020,  010,  0374,   /*  'Z'  */
  306. 5, 0,    0,    0340, 0200, 0200, 0200, 0200, 0200, 0340,   /*  '['  */
  307. 9, 0,    0,    02,   04,   010,  020,  040,  0100, 0200,   /*  '\'  */
  308. 5, 0,    0,    0340, 040,  040,  040,  040,  040,  0340,   /*  ']'  */
  309. 6, 0,    0,    0,    0,    0,    0,    0210, 0120, 040,    /*  '^'  */
  310. 8, 0,    0377, 0,    0,    0,    0,    0,    0,    0,      /*  '_'  */
  311. 4, 0,    0,    0,    0,    0,    0,    040,  040,  0100,   /*  '`'  */
  312. 8, 0,    0,    0164, 0210, 0170, 010,  0360, 0,    0,      /*  'a'  */
  313. 7, 0,    0,    0360, 0210, 0210, 0210, 0360, 0200, 0200,   /*  'b'  */
  314. 7, 0,    0,    0170, 0200, 0200, 0200, 0170, 0,    0,      /*  'c'  */
  315. 8, 0,    0,    0164, 0210, 0210, 0210, 0170, 010,  010,    /*  'd'  */
  316. 8, 0,    0,    0170, 0200, 0370, 0204, 0170, 0,    0,      /*  'e'  */
  317. 6, 0,    0,    0100, 0100, 0100, 0340, 0100, 0110, 060,    /*  'f'  */
  318. 7, 0360, 010,  0170, 0210, 0210, 0210, 0160, 0,    0,      /*  'g'  */
  319. 7, 0,    0,    0210, 0210, 0210, 0210, 0360, 0200, 0200,   /*  'h'  */
  320. 5, 0,    0,    0340, 0100, 0100, 0100, 0300, 0,    0100,   /*  'i'  */
  321. 7, 0140, 0220, 020,  020,  020,  020,  020,  0,    020,    /*  'j'  */
  322. 7, 0,    0,    0210, 0220, 0240, 0300, 0240, 0220, 0200,   /*  'k'  */
  323. 5, 0,    0,    0340, 0100, 0100, 0100, 0100, 0100, 0300,   /*  'l'  */
  324. 9, 0,    0,    0222, 0222, 0222, 0222, 0356, 0,    0,      /*  'm'  */
  325. 8, 0,    0,    0104, 0104, 0104, 0104, 0270, 0,    0,      /*  'n'  */
  326. 7, 0,    0,    0160, 0210, 0210, 0210, 0160, 0,    0,      /*  'o'  */
  327. 7, 0200, 0200, 0360, 0210, 0210, 0210, 0360, 0,    0,      /*  'p'  */
  328. 7, 010,  010,  0170, 0210, 0210, 0210, 0170, 0,    0,      /*  'q'  */
  329. 6, 0,    0,    0200, 0200, 0200, 0310, 0260, 0,    0,      /*  'r'  */
  330. 7, 0,    0,    0360, 010,  0160, 0200, 0170, 0,    0,      /*  's'  */
  331. 7, 0,    0,    020,  050,  040,  040,  0370, 040,  040,    /*  't'  */
  332. 8, 0,    0,    0164, 0210, 0210, 0210, 0210, 0,    0,      /*  'u'  */
  333. 8, 0,    0,    040,  0120, 0210, 0210, 0210, 0,    0,      /*  'v'  */
  334. 9, 0,    0,    0104, 0252, 0222, 0222, 0202, 0,    0,      /*  'w'  */
  335. 8, 0,    0,    0210, 0120, 040,  0120, 0210, 0,    0,      /*  'x'  */
  336. 8, 0360, 010,  0170, 0210, 0210, 0210, 0210, 0,    0,      /*  'y'  */
  337. 8, 0,    0,    0370, 0100, 040,  020,  0370, 0,    0,      /*  'z'  */
  338. 6, 0,    0,    060,  0100, 0100, 0200, 0100, 0100, 060,    /*  '{'  */
  339. 3, 0,    0,    0200, 0200, 0200, 0,    0200, 0200, 0200,   /*  '|'  */
  340. 7, 0,    0,    0300, 040,  040,  020,  040,  040,  0300,   /*  '}'  */
  341. 7, 0,    0,    0,    0,    0,    0,    020,  0250, 0100,   /*  '~'  */
  342. 7, 0,    0,    040,  0160, 0250, 040,  040,  0,    0,      /*  'd'  */
  343. };
  344.  
  345. alpha_plot(c)
  346. char c;
  347. {
  348.     int width;
  349.     int index = c - ' ';
  350.     char *ptr;
  351.     short x,y,i,j;
  352.  
  353.     if((index < 0) || (index >= sizeof(table))) return;
  354.  
  355.     ptr = table[index];
  356.     width = ((int)*ptr++ & 0377);
  357.  
  358.     /* Move so that the character is plotted with its center (approx)
  359.      * is plotted at the current point.  We have to undo this at the
  360.      * end.
  361.      */
  362.     curxdot -= 3;
  363.     curydot -= 3;
  364.     /* this is a hack--character height changes due to different
  365.      * dot densities in x and y.  we restore this at the end.
  366.      */
  367.     if(Rotate) --curydot;
  368.     
  369.     for(i = 0;i < 9; ++i)
  370.     {
  371.         if(ptr[i])
  372.         {
  373.             for(j = 0; j < 8; ++j)
  374.             {
  375.                 if(plotbit(ptr[i],j))
  376.                 {
  377.                     x = curxdot + 7 - j;
  378.                     y = curydot + i - 2;
  379.                     point(x,y);
  380.                 }
  381.             }
  382.         }
  383.     }
  384.     if(Rotate)
  385.     {
  386.         /* different dot densities, again                            */
  387.         width = (double)width * YPERINCH / XPERINCH;
  388.         curydot++;    /* end hack                                        */
  389.     }
  390.     curx += (double)width/mapxfac;
  391.     curxdot += 3;
  392.     curydot += 3;
  393.     curxdot += width;
  394. }
  395. SHAR_EOF
  396. if test 9282 -ne "`wc -c < 'alpha_plot.c'`"
  397. then
  398.     echo shar: error transmitting "'alpha_plot.c'" '(should have been 9282 characters)'
  399. fi
  400. fi
  401. echo shar: extracting "'functions.c'" '(11457 characters)'
  402. if test -f 'functions.c'
  403. then
  404.     echo shar: will not over-write existing file "'functions.c'"
  405. else
  406. cat << \SHAR_EOF > 'functions.c'
  407. /* :set tabstops=4                                                    */
  408. static char *RCSid = "$Header: functions.c,v 1.1 86/04/20 16:16:38 sysad Exp $";
  409.  
  410. /*
  411.  * $Log:    functions.c,v $
  412.  * Revision 1.1  86/04/20  16:16:38  sysad
  413.  * Initial distribution version
  414.  * 
  415.  * 
  416.  */
  417.  
  418.  
  419. /* It is the intent of the author that this software may be distributed
  420.  * and used freely, without restriction.  If you make improvements or
  421.  * enhancements, I would appreciate a copy.
  422.  *
  423.  * Duane H. Hesser    Teltone Corporation
  424.  * ....uw-beaver!tikal!sysad
  425.  * ....uw-beaver!tikal!dhh
  426.  */
  427.  
  428. #include "defs.h"
  429. #include "extern.h"
  430.  
  431. space(x0,y0,x1,y1)
  432. short x0,y0,x1,y1;
  433. {
  434.     static int noinit = 1;
  435.     double tmp;
  436.  
  437. #ifdef DEBUG
  438.     if(debug & 1) printf("space(%d,%d,%d,%d)\n",x0,y0,x1,y1);
  439. #endif
  440.     lowx_space = (double)x0;
  441.     lowy_space = (double)y0;
  442.     highx_space = (double)x1;
  443.     highy_space = (double)y1;
  444.     xspace = highx_space - lowx_space;
  445.     yspace = highy_space - lowy_space;
  446.     if(maxcol > XDOTS) maxcol = XDOTS;
  447.     if(maxrow > YDOTS) maxrow = YDOTS;
  448. #ifdef QUICKPLOT
  449.     /* Autowrap can be a problem; some terminals and/or screen packages
  450.      * wrap early (i.e., they wrap when the last character is
  451.      * placed in the row, rather than waiting for the next character.
  452.      * Safest way seems to be to waste a column.
  453.      */
  454.     if(autowrap) maxcol--;
  455. #endif
  456.     maxx = maxcol - 1;
  457.     maxy = maxrow - 1;
  458.     if(Rotate)
  459.     {
  460.         if(noinit)
  461.         {
  462.             noinit = 0;
  463.             tmp = spacex;
  464.             spacex = spacey;
  465.             spacey = tmp;
  466.             tmp = maxx;
  467.             maxx = maxy;
  468.             maxy = tmp;
  469.             /* re-compute the margins */
  470.             tmp = (Xmargin / XPERINCH) * YPERINCH;
  471.             Xmargin = (Ymargin / YPERINCH) * XPERINCH;
  472.             Ymargin = tmp;
  473.         }
  474.     }
  475.     if(spacex > maxx) spacex = maxx;
  476.     if(spacey > maxy) spacey = maxy;
  477.     xfac = ( spacex/xspace ) * argxfac;
  478.     yfac = ( spacey/yspace ) * argyfac;
  479.     mapxfac = xfac * Scalfac;
  480.     mapyfac = yfac * Scalfac;
  481. #ifdef DEBUG
  482.     if(debug &2)
  483.     {
  484.         printf("maxrow=%d,maxcol=%d,maxx=%d,maxy=%d\n",maxrow,maxcol,maxx,maxy);
  485.         printf("xfac=%G,yfac=%G,mapxfac=%G,mapyfac=%G\n",xfac,yfac,mapxfac,mapyfac);
  486.         printf("spacex=%G,spacey=%G,xspace=%G,yspace=%G\n",spacex,spacey,xspace,yspace);
  487.     }
  488. #endif
  489. }
  490.  
  491. cont(x,y)
  492. short x,y;
  493. {
  494.     x = (short)mapx(x);
  495.     y = (short)mapy(y);
  496.     make_line(curxdot,curydot,x,y);
  497.     curxdot = x;
  498.     curydot = y;
  499. #ifdef DEBUG
  500.     if(debug & 1) printf("cont(%d,%d)\n",curxdot,curydot);
  501. #endif
  502. }
  503.  
  504. move(x,y)
  505. short x,y;
  506. {
  507.     curxdot = (short)mapx(x);
  508.     curydot = (short)mapy(y);
  509. #ifdef DEBUG
  510.     if(debug & 1) printf("move(%d,%d)\n",curxdot,curydot);
  511. #endif
  512. }
  513.  
  514. line(x0,y0,x1,y1)
  515. short x0,y0,x1,y1;
  516. {
  517.     x0 = (short)mapx(x0);
  518.     x1 = (short)mapx(x1);
  519.     y0 = (short)mapy(y0);
  520.     y1 = (short)mapy(y1);
  521.     make_line(x0,y0,x1,y1);
  522. #ifdef DEBUG
  523.     if(debug & 1) printf("line(%d,%d,%d,%d)\n",x0,y0,x1,y1);
  524. #endif
  525.     curxdot = x1;
  526.     curydot = y1;
  527. }
  528.  
  529. make_line(x0,y0,x1,y1)
  530. short x0,y0,x1,y1;
  531. {
  532.     short xdots,ydots,i,j,signx,signy;
  533.     double tanxy;
  534. #ifdef QUICKPLOT
  535.     char pc = plotchar;
  536. #endif
  537.  
  538.     xdots = x1 - x0;
  539.     ydots = y1 - y0;
  540.     signx = (xdots > 0) ? 1 : -1;
  541.     signy = (ydots > 0) ? 1 : -1;
  542.     point(x0,y0);
  543.     if(xdots == 0)
  544.     {
  545.         if(ydots == 0) return;
  546.         for(i = signy; i != ydots; i += signy)
  547.         {
  548. #ifndef QUICKPLOT
  549.             if(!(abs(i) & linemask)) continue;
  550. #else
  551.             if(abs(i) & 1) plotchar = linemask;
  552.             else plotchar = pc;
  553. #endif
  554.             point(x0,y0 + i);
  555.         }
  556.     }
  557.     else if(ydots == 0)
  558.     {
  559.         for(i = signx; i != xdots; i += signx)
  560.         {
  561. #ifndef QUICKPLOT
  562.             if(!(abs(i) & linemask)) continue;
  563. #else
  564.             if(abs(i) & 1) plotchar = linemask;
  565.             else plotchar = pc;
  566. #endif
  567.             point(x0 + i,y0);
  568.         }
  569.     }
  570.     else if(abs(xdots) >= abs(ydots))
  571.     {
  572.         tanxy = (double)ydots / (double)xdots;
  573.         for(i = signx; i != xdots; i += signx)
  574.         {
  575. #ifndef QUICKPLOT
  576.             if(!(abs(i) & linemask)) continue;
  577. #else
  578.             if(abs(i) & 1) plotchar = linemask;
  579.             else plotchar = pc;
  580. #endif
  581.             j = i * tanxy;
  582.             point(x0 + i,y0 + j);
  583.         }
  584.     }
  585.     else
  586.     {
  587.         tanxy = (double)xdots / (double)ydots;
  588.         for(i = signy; i != ydots; i += signy)
  589.         {
  590. #ifndef QUICKPLOT
  591.             if(!(abs(i) & linemask)) continue;
  592. #else
  593.             if(abs(i) & 1) plotchar = linemask;
  594.             else plotchar = pc;
  595. #endif
  596.             j = i * tanxy;
  597.             point(x0 + j,y0 + i);
  598.         }
  599.     }
  600.     point(x1,y1);
  601. #ifdef QUICKPLOT
  602.     plotchar = pc;
  603. #endif
  604. }
  605.  
  606.  
  607. circle(x,y,r)
  608. short x,y,r;
  609. {
  610.     short x0;
  611.  
  612.     x0 = x + r;
  613.     arc(x,y,x0,y,x0,y);
  614.     move(x,y);
  615. }
  616.  
  617. label(str,len)
  618. char *str;
  619. int len;
  620. {
  621.     int i;
  622.     char *rp;
  623.  
  624. #ifdef DEBUG
  625.     if(debug & 1) printf("label(%s,%d)\n",str,len);
  626. #endif
  627.     for(i=0; i < len && str[i] != '\n'; i++) 
  628.     {
  629.         if((str[i] < ' ') || (str[i] >= '\177')) continue;
  630. #ifndef QUICKPLOT
  631.         alpha_plot(str[i]);
  632. #else
  633.         if(Rotate)
  634.         {
  635.             rp = &Row[curxdot][maxy-curydot];
  636.             if(*rp && (*rp != plotchar))  ++curxdot;
  637.             Row[curxdot][maxy-curydot] = str[i];
  638.         }
  639.         else
  640.         {
  641.             rp = &Row[curydot][curxdot];
  642.             if(*rp && (*rp != plotchar))  ++curxdot;
  643.             Row[curydot][curxdot] = str[i];
  644.         }
  645. #endif
  646.     }
  647. }
  648.  
  649. #ifndef QUICKPLOT
  650. point(x,y)
  651. short x,y;
  652. {
  653.     short row,byte,bit;
  654.     if(x > maxx)
  655.     {
  656.         x = maxx;
  657.     }
  658.     else if(x < 0)
  659.     {
  660.         x = 0;
  661.     }
  662.     if(y > maxy)
  663.     {
  664.         y = maxy;
  665.     }
  666.     else if(y < 0)
  667.     {
  668.         y = 0;
  669.     }
  670.  
  671.     if(Rotate)
  672.     {
  673.         row = x;
  674.         byte = (maxy - y) / 6;
  675.         bit = 5 - (y % 6);
  676.     }
  677.     else
  678.     {
  679.         row = y;
  680.         byte = x/6;
  681.         bit = x%6;
  682.     }
  683.     Row[row][byte] |= BIT[bit];
  684. }
  685.  
  686. #else QUICKPLOT
  687.  
  688. point(x,y)
  689. short x,y;
  690. {
  691.     short row,col;
  692.     char pc;
  693.  
  694.     pc = plotchar;
  695.     if(x > maxx)
  696.     {
  697.         x = maxx;
  698.         pc = '@';
  699.     }
  700.     else if(x < 0)
  701.     {
  702.         x = 0;
  703.         pc = '@';
  704.     }
  705.     if(y > maxy)
  706.     {
  707.         y = maxy;
  708.         pc = '@';
  709.     }
  710.     else if(y < 0)
  711.     {
  712.         y = 0;
  713.         pc = '@';
  714.     }
  715.  
  716.     if(Rotate)
  717.     {
  718.         row = x;
  719.         col = maxy - y;
  720.     }
  721.     else
  722.     {
  723.         row = y;
  724.         col = x;
  725.     }
  726.     if(!Row[row][col]) Row[row][col] = pc;
  727. }
  728. #endif QUICKPLOT
  729.  
  730. /* Make an arc with (x,y) as center, (x0,y0) as starting point,
  731.  * and (x1,y1) as end point.
  732.  *
  733.  * The algorithm here is simpler than it looks; the intent is to
  734.  * compute the points required just once in the first quadrant,
  735.  * then reflect them across the axes or origin if they are required
  736.  * in the other quadrants.
  737.  * 1. Find the starting and ending quadrants.
  738.  * 2. Verify the end point, and make sure it is on the arc thru (x0,y0)
  739.  *    with center (x,Y).
  740.  * 3. Determine which quadrants require points to be plotted.
  741.  * 4. Determine the minimum and maximum "y" deltas in each quadrant.
  742.  *    and set the starting point for line drawing in each quadrant.
  743.  * 5. Pot the arc by incrementing the delta "y" and computing the
  744.  *    corresponding "x" delta in the first quadrant.  Then check each
  745.  *    quadrant to see if the corresponding point is needed, and draw a
  746.  *    line from the last point plotted in that quadrant to the current
  747.  *    point in that quadrant.
  748.  */
  749. #include <math.h>
  750. arc(x,y,x0,y0,x1,y1)
  751. short x,y,x0,y0,x1,y1;
  752. {
  753.     int i,ystart,ymax,dx,dy,sq,endq,nq;
  754.     int q[4],qmin[4],qmax[4];
  755.     short lx[4],ly[4],nx,ny,r,rx,ry;
  756.     double asin(),sin(),cos(),ra,theta;
  757.  
  758. #ifdef DEBUG
  759.     if(debug & 3)
  760.         printf("to arc(%d,%d,%d,%d,%d,%d)\n",x,y,x0,y0,x1,y1);
  761. #endif
  762.     /* find starting quadrant                                        */
  763.     if(y0 >= y)
  764.     {
  765.         if(x0 > x) sq = 1;
  766.         else if(y0 == y) sq = 3;
  767.         else sq = 2;
  768.     }
  769.     else if(x0 >= x) sq = 4;
  770.     else sq = 3;
  771.     /* find ending quadrant                                            */
  772.     if(x1 >= x)
  773.     {
  774.         if(y1 > y) endq = 1;
  775.         else if(x1 == x) endq = 3;
  776.         else endq = 4;
  777.     }
  778.     else if(y1 >= y) endq = 2;
  779.     else endq = 3;
  780.  
  781.     /* The calling program can easily pass a phony x1,y1 which
  782.      * doesn't lie on the arc thru x0,y0 with center x,y.
  783.      * Fix it.
  784.      */
  785.     dx = abs(x0 - x); dy = abs(y0 - y);
  786.     if(dx == 0)
  787.     {
  788.         if(dy == 0) return;    /* 0 radius; that's easy            */
  789.         r = dy;
  790.     }
  791.     else if(dy == 0) r = dx;
  792.     else
  793.     {
  794.         r = sqrt(((double)dx * (double)dx) + ((double)dy * (double)dy));
  795.         /* r should never be <= 0, unless integer truncation occurs    */
  796.         if(r <= 0) r = 1;
  797.     }
  798.  
  799.     ra = (double)abs(y1 - y) / (double)r;
  800.     theta = asin(ra);
  801.     dx = r * cos(theta) + 0.5;
  802.     dy = r * sin(theta) + 0.5;
  803.     /* make sure these are positive                                    */
  804.     if((dx == 0) && (dy == 0)) return;
  805.     r = abs((int)r);
  806.     dx = abs(dx);
  807.     dy = abs(dy);
  808.  
  809.     if(debug & 3) printf("dx=%d,dy=%d\n",dx,dy);
  810.     if(endq & 2) x1 = x - dx;
  811.     else x1 = x + dx;
  812.     if(endq > 2) y1 = y - dy;
  813.     else y1 = y + dy;
  814.     if(debug & 3) printf("x1=%d,y1=%d\n",x1,y1);
  815.  
  816.     /* Map to device units.  Radius is mapped for both x direction
  817.      * and y direction because resolution differs in the two directions.
  818.      */
  819.     x = (short)mapx(x);
  820.     x0 = (short)mapx(x0);
  821.     x1 = (short)mapx(x1);
  822.     y = (short)mapy(y);
  823.     y0 = (short)mapy(y0);
  824.     y1 = (short)mapy(y1);
  825.     rx = (short)(((double)r * mapxfac) + .01);
  826.     ry = (short)(((double)r * mapyfac) + .01);
  827.  
  828.     /* Mark the quadrants which require plotting.
  829.      * Note that quadrants are numbered from 1-4, just like in math
  830.      * class, but the "q" arrays run from 0-3
  831.      */
  832.     q[0] = q[1] = q[2] = q[3] = 0;
  833.     if(sq <= endq)
  834.     {
  835.         for(i = sq; i <= endq; ++i)
  836.         {
  837.             ++q[i - 1];
  838.             nq++;        /* number of quadrants                        */
  839.         }
  840.     }
  841.     else
  842.     {
  843.         for(i = sq; i <= 4; ++i)
  844.         {
  845.             ++q[i - 1];
  846.             nq++;
  847.         }
  848.         for(i = 1; i <= endq; ++i)
  849.         {
  850.             ++q[i - 1];
  851.             nq++;
  852.         }
  853.     }
  854.     if(debug & 1)
  855.     {
  856.         printf("arc(%d,%d,%d,%d,%d,%d)\n",x,y,x0,y0,x1,y1);
  857.         printf("(radius=%d,%d,%d)\n",r,rx,ry);;
  858.     }
  859.  
  860.     /* find the min and max y increments                            */
  861.     if(nq >= 3)
  862.     {
  863.         ystart = 0;
  864.         ymax = ry;
  865.     }
  866.     else if(nq == 1)
  867.     {
  868.         if((sq == 1) || (sq == 3))
  869.         {
  870.             ystart = abs(y0 - y);
  871.             ymax = abs(y1 - y);
  872.         }
  873.         else
  874.         {
  875.             ymax = abs(y0 - y);
  876.             ystart = abs(y1 - y);
  877.         }
  878.     }
  879.     else if((sq + endq) == 5)    /* 1 & 4 or 2 & 3                    */
  880.     {
  881.         ystart = 0;
  882.         ymax = (abs(y0 - y) > abs(y1 - y)) ? abs(y0 - y) : abs(y1 - y);
  883.     }
  884.     else
  885.     {
  886.         ymax = ry;
  887.         ystart = (abs(y0 - y) > abs(y1 - y)) ? abs(y1 - y) : abs(y0 - y);
  888.     }
  889.     /* now find the min and max y increments for each quadrant        */
  890.     if(q[0])        /* 1st quadrant                                    */
  891.     {
  892.         if(sq == 1)
  893.         {
  894.             qmin[0] = y0 - y;
  895.             ly[0] = y0;
  896.             lx[0] = x0;
  897.         }
  898.         else
  899.         {
  900.             qmin[0] = 0;
  901.             ly[0] = y;
  902.             lx[0] = x + rx;
  903.         }
  904.         if(endq == 1) qmax[0] = y1 - y;
  905.         else qmax[0] = ry;
  906.     }
  907.     if(q[1])        /* 2nd quadrant                                    */
  908.     {
  909.         if(sq == 2)
  910.         {
  911.             qmax[1] = y0 - y;
  912.         }
  913.         else
  914.         {
  915.             qmax[1] = ry;
  916.         }
  917.         if(endq == 2)
  918.         {
  919.             qmin[1] = y1 - y;
  920.             ly[1] = y1;
  921.             lx[1] = x1;
  922.         }
  923.         else
  924.         {
  925.             qmin[1] = 0;
  926.             ly[1] = y;
  927.             lx[1] = x - rx;
  928.         }
  929.     }
  930.     if(q[2])        /* 3rd    quadrant                                */
  931.     {
  932.         if(sq == 3)
  933.         {
  934.             qmin[2] = y - y0;
  935.             ly[2] = y0;
  936.             lx[2] = x0;
  937.         }
  938.         else
  939.         {
  940.             qmin[2] = 0;
  941.             ly[2] = y;
  942.             lx[2] = x - rx;
  943.         }
  944.         if(endq == 3)
  945.         {
  946.             qmax[2] = y - y1;
  947.         }
  948.         else
  949.         {
  950.             qmax[2] = ry;
  951.         }
  952.     }
  953.     if(q[3])        /* 4th quadrant                                    */
  954.     {
  955.         if(sq == 4)
  956.         {
  957.             qmax[3] = y - y0;
  958.         }
  959.         else
  960.         {
  961.             qmax[3] = ry;
  962.         }
  963.         if(endq == 4)
  964.         {
  965.             qmin[3] = y - y1;
  966.             ly[3] = y1;
  967.             lx[3] = x1;
  968.         }
  969.         else
  970.         {
  971.             qmin[3] = 0;
  972.             ly[3] = y;
  973.             lx[3] = x + rx;
  974.         }
  975.     }
  976. #ifdef DEBUG
  977.     if(debug & 3)
  978.     {
  979.         printf("sq=%d,endq=%d,ystart=%d,ymax=%d\n",sq,endq,ystart,ymax);
  980.         printf("q\t  min \t  max \t  lx  \t  ly\n");
  981.         for(i=0; i < 4; ++i)
  982.         {
  983.             if(q[i])
  984.                 printf("%d\t%d\t%d\t%d\t%d\n",i+1,qmin[i],qmax[i],lx[i],ly[i]);
  985.         }
  986.     }
  987. #endif DEBUG
  988.     /* finally ready to plot                                        */
  989.     for(i = ystart; i <= ymax; ++i)
  990.     {
  991.         ra = ry ? (double)i / (double)ry: 0;
  992.         theta = asin(ra);
  993.         dx = (double)rx * cos(theta) + 0.5;
  994.         if(q[0] && (i >= qmin[0]) && (i <= qmax[0]))
  995.         {
  996.             nx = x + dx;
  997.             ny = y + i;
  998.             make_line(lx[0],ly[0],nx,ny);
  999.             lx[0] = nx;
  1000.             ly[0] = ny;
  1001.         }
  1002.         if(q[1] && (i >= qmin[1]) && (i <= qmax[1]))
  1003.         {
  1004.             nx = x - dx;
  1005.             ny = y + i;
  1006.             make_line(lx[1],ly[1],nx,ny);
  1007.             lx[1] = nx;
  1008.             ly[1] = ny;
  1009.         }
  1010.         if(q[2] && (i >= qmin[2]) && (i <= qmax[2]))
  1011.         {
  1012.             nx = x - dx;
  1013.             ny = y - i;
  1014.             make_line(lx[2],ly[2],nx,ny);
  1015.             lx[2] = nx;
  1016.             ly[2] = ny;
  1017.         }
  1018.         if(q[3] && (i >= qmin[3]) && (i <= qmax[3]))
  1019.         {
  1020.             nx = x + dx;
  1021.             ny = y - i;
  1022.             make_line(lx[3],ly[3],nx,ny);
  1023.             lx[3] = nx;
  1024.             ly[3] = ny;
  1025.         }
  1026.     }
  1027. }
  1028. SHAR_EOF
  1029. if test 11457 -ne "`wc -c < 'functions.c'`"
  1030. then
  1031.     echo shar: error transmitting "'functions.c'" '(should have been 11457 characters)'
  1032. fi
  1033. fi
  1034. echo shar: extracting "'global.c'" '(2962 characters)'
  1035. if test -f 'global.c'
  1036. then
  1037.     echo shar: will not over-write existing file "'global.c'"
  1038. else
  1039. cat << \SHAR_EOF > 'global.c'
  1040. /* :set tabstops=4                                                    */
  1041. static char *RCSid = "$Header: global.c,v 1.1 86/04/20 16:16:41 sysad Exp $";
  1042.  
  1043. /*
  1044.  * $Log:    global.c,v $
  1045.  * Revision 1.1  86/04/20  16:16:41  sysad
  1046.  * Initial distribution version
  1047.  * 
  1048.  * 
  1049.  */
  1050.  
  1051.  
  1052. /* It is the intent of the author that this software may be distributed
  1053.  * and used freely, without restriction.  If you make improvements or
  1054.  * enhancements, I would appreciate a copy.
  1055.  *
  1056.  * Duane H. Hesser    Teltone Corporation
  1057.  * ....uw-beaver!tikal!sysad
  1058.  * ....uw-beaver!tikal!dhh
  1059.  */
  1060.  
  1061. #include "defs.h"
  1062. #include "io.h"
  1063.  
  1064. /* This is the output array; it should be big enough for the largest
  1065.  * "raster" which will be used (currently the full size of an 11 x 13.2
  1066.  * inch line printer page).
  1067.  */
  1068. char Row[YDOTS][XARRAYSIZE];
  1069. #ifndef QUICKPLOT
  1070. /* These are the bits which are or'ed into the output array to acivate
  1071.  * the appropriate hammers.
  1072.  */
  1073. char BIT[] = {
  1074.     '\001','\002','\004','\010','\020','\040','\100','\0'
  1075. };
  1076. #else
  1077. char plotchar = PLOTCHAR;
  1078. int autowrap = 0;            /* does the terminal auto-wrap at eol?    */
  1079. #endif
  1080.  
  1081. /* Initially, we map everything into an 8 inch square for lplot,
  1082.  * or into a 132 wide x 66 line "screen" for quickplot.  The 8 inch
  1083.  * square for lplot is consistent with scaling for things like
  1084.  * "vplot" which plot onto an 8 1/2 x 11 inch page.
  1085.  * The values initialized may be changed (within array size limits
  1086.  * by program arguments, and will take effect at the first space()
  1087.  * call.
  1088.  */
  1089. double spacex = SPACEX;
  1090. double spacey = SPACEY;
  1091.  
  1092. /* These are the program units which will map into spacex & spacey
  1093.  * after the space() call.
  1094.  */
  1095. double xspace,yspace;
  1096.  
  1097. /* min and max points mapped into the plotting space by space()        */
  1098. double highx_space,highy_space,lowx_space,lowy_space;
  1099.  
  1100. /* maximum dots each direction; truncate larger values.                */
  1101. int maxrow = YDOTS;
  1102. int maxcol = XDOTS;
  1103. /* maximum x and y values; generally one less than maxrow, maxcol    */
  1104. int maxx = MAXX;
  1105. int maxy = MAXY;
  1106.  
  1107. /* current coordinates in program units and dots                    */
  1108. short curx,cury,curxdot,curydot;
  1109.  
  1110. double Scalfac = 1.0;            /* settable overall scale factor    */
  1111. double xfac = 1.0;                /* scale factor for x                */
  1112. double yfac = 1.0;                /* scale factor for y                */
  1113. double argxfac = 1.0;            /* argument scale factor for x        */
  1114. double argyfac = 1.0;            /* argument scale factor for y        */
  1115. double mapxfac = 1.0;            /* final mapping factor for x         */
  1116. double mapyfac = 1.0;            /* final mapping factor for y        */
  1117. double Xmargin = 0.0;            /* settable left margin in pixels    */
  1118. double Ymargin = 0.0;            /* settable bottom margin in pixels    */
  1119.  
  1120. int Plotdata = 0;                /* set when raster is ready to send    */
  1121. int Eflag = 0;                    /* force erase before each plot        */
  1122. int Nflag = 0;                    /* suppress erasing while in effect    */
  1123. #ifdef QUICKPLOT
  1124. int linemask = PLOTCHAR;        /* solid, dotted, dashed, etc.        */
  1125. #else
  1126. int linemask = SOLID;            /* solid, dotted, dashed, etc.        */
  1127. #endif
  1128.  
  1129. char *Name;
  1130. int debug = 0;
  1131.  
  1132. #ifndef QUICKPLOT
  1133. int Npages = 0;
  1134. #endif
  1135. int Rotate = 0;
  1136. SHAR_EOF
  1137. if test 2962 -ne "`wc -c < 'global.c'`"
  1138. then
  1139.     echo shar: error transmitting "'global.c'" '(should have been 2962 characters)'
  1140. fi
  1141. fi
  1142. echo shar: extracting "'iobuf.c'" '(2781 characters)'
  1143. if test -f 'iobuf.c'
  1144. then
  1145.     echo shar: will not over-write existing file "'iobuf.c'"
  1146. else
  1147. cat << \SHAR_EOF > 'iobuf.c'
  1148. /* :set tabstops=4                                                    */
  1149. static char *RCSid = "$Header: iobuf.c,v 1.1 86/04/20 16:16:43 sysad Exp $";
  1150.  
  1151. /*
  1152.  * $Log:    iobuf.c,v $
  1153.  * Revision 1.1  86/04/20  16:16:43  sysad
  1154.  * Initial distribution version
  1155.  * 
  1156.  * 
  1157.  */
  1158.  
  1159. /* An utterly simple buffering scheme; it's all we need.            */
  1160.  
  1161. /* It is the intent of the author that this software may be distributed
  1162.  * and used freely, without restriction.  If you make improvements or
  1163.  * enhancements, I would appreciate a copy.
  1164.  *
  1165.  * Duane H. Hesser    Teltone Corporation
  1166.  * ....uw-beaver!tikal!sysad
  1167.  * ....uw-beaver!tikal!dhh
  1168.  */
  1169.  
  1170. #include    "io.h"
  1171.  
  1172. bufopen(file,io)
  1173. char *file;
  1174. struct inbuf *io;
  1175. {
  1176.  
  1177.     if((io->fd = open(file,0)) < 0)
  1178.         return(-1);
  1179.     io->nleft = 0;
  1180.     io->eof = 0;
  1181.     return(io->fd);
  1182. }
  1183.  
  1184. bufclose(io)
  1185. struct inbuf *io;
  1186. {
  1187.     if(io->fd >= 0) close(io->fd);
  1188.     io->eof = 1;
  1189.     io->nleft = 0;
  1190.     io->fd = -1;
  1191. }
  1192.  
  1193. char
  1194. getbyte(io)
  1195. struct inbuf *io;
  1196. {
  1197.     char next,ebuf[32];
  1198.  
  1199.     if(io->nleft <= 0)
  1200.     {
  1201.         if(io->fd < 0)
  1202.         {
  1203.             sprintf(ebuf,"%s: unopen file error in getbyte()\n");
  1204.             write(2,ebuf,strlen(ebuf));
  1205.             exit(69);
  1206.         }
  1207.         io->nleft = read(io->fd,io->buff,INBUFSIZE);
  1208.         if(io->nleft < 0)
  1209.         {
  1210.             sprintf(ebuf,"%s: read error in getbyte()\n");
  1211.             write(2,ebuf,strlen(ebuf));
  1212.             exit(69);
  1213.         }
  1214.         io->nextp = io->buff;
  1215.     }
  1216.     if(io->nleft-- <= 0)
  1217.     {
  1218.         io->eof++;
  1219.         return('\0');
  1220.     }
  1221.     next = *(io->nextp++) & '\377';
  1222.     return(next);
  1223. }
  1224.  
  1225.  
  1226.  
  1227. getstr(io,buf)
  1228. struct inbuf *io;
  1229. char *buf;
  1230. {
  1231.     char *ptr = buf;
  1232.     char getbyte();
  1233.  
  1234.     while( *ptr = getbyte(io) )
  1235.     {
  1236.         if(*ptr++ == '\n')
  1237.         {
  1238.             *--ptr = '\0';
  1239.             break;
  1240.         }
  1241.     }
  1242.     return(strlen(buf));
  1243. }
  1244.  
  1245.  
  1246. #ifdef BIGENDIAN
  1247. union {
  1248.     short sh_word;
  1249.     struct {
  1250.         char hi_byte;
  1251.         char lo_byte;
  1252.     } sh_bytes;
  1253. } sh;
  1254. #else
  1255. union {
  1256.     short sh_word;
  1257.     struct {
  1258.         char lo_byte;
  1259.         char hi_byte;
  1260.     } sh_bytes;
  1261. } sh;
  1262. #endif
  1263. short
  1264. getshort(io)
  1265. struct inbuf *io;
  1266. {
  1267.     char c,ebuf[32];
  1268.  
  1269.     c = getbyte(io);
  1270.     if(eof(io))
  1271.     {
  1272.         sprintf(ebuf,"unexpected EOF in getshort()\n");
  1273.         write(2,ebuf,strlen(ebuf));
  1274.         exit(69);
  1275.     }
  1276.     else sh.sh_bytes.lo_byte = c;
  1277.  
  1278.     c = getbyte(io);
  1279.     if(eof(io))
  1280.     {
  1281.         sprintf(ebuf,"unexpected EOF in getshort()\n");
  1282.         write(2,ebuf,strlen(ebuf));
  1283.         exit(69);
  1284.     }
  1285.     else sh.sh_bytes.hi_byte = c;
  1286.     return(sh.sh_word);
  1287. }
  1288.  
  1289. eof(source)
  1290. struct inbuf *source;
  1291. {
  1292.     return(source->eof);
  1293. }
  1294.  
  1295.  
  1296. /* Note that we don't even bother to "open" for output; just use
  1297.  * file descriptor 1 (normally stdout)
  1298.  */
  1299. bufwrite(from,len,outbuf)
  1300. char *from;
  1301. int len;
  1302. struct outbuf *outbuf;
  1303. {
  1304.     if(len <= 0) return;
  1305.     if((len + outbuf->datalen) > OUTBUFSIZE) buf_flush(outbuf);
  1306.     bcopy(from,outbuf->nextp,len);
  1307.     outbuf->datalen += len;
  1308.     outbuf->nextp += len;
  1309.     if((len + outbuf->datalen) >= OUTBUFSIZE) buf_flush(outbuf);
  1310. }
  1311.  
  1312. buf_flush(buf)
  1313. struct outbuf *buf;
  1314. {
  1315.     if(buf->datalen > 0) write(1,buf->buffer,buf->datalen);
  1316.     buf->nextp = buf->buffer;
  1317.     buf->datalen = 0;
  1318. }
  1319. SHAR_EOF
  1320. if test 2781 -ne "`wc -c < 'iobuf.c'`"
  1321. then
  1322.     echo shar: error transmitting "'iobuf.c'" '(should have been 2781 characters)'
  1323. fi
  1324. fi
  1325. echo shar: extracting "'lplot.c'" '(7614 characters)'
  1326. if test -f 'lplot.c'
  1327. then
  1328.     echo shar: will not over-write existing file "'lplot.c'"
  1329. else
  1330. cat << \SHAR_EOF > 'lplot.c'
  1331. /* :set tabstops=4                                                    */
  1332. static char *RCSid = "$Header: lplot.c,v 1.1 86/04/20 16:16:46 sysad Exp $";
  1333.  
  1334. /*
  1335.  * $Log:    lplot.c,v $
  1336.  * Revision 1.1  86/04/20  16:16:46  sysad
  1337.  * Initial distribution version
  1338.  * 
  1339.  * 
  1340.  */
  1341.  
  1342.  
  1343. /* LPLOT and QUICKPLOT -- main program.
  1344.  * This file handles initialization (mostly argument gathering),
  1345.  * calls the plot function to fill the output array, then processes
  1346.  * the array and outputs it.
  1347.  */
  1348.  
  1349. /* It is the intent of the author that this software may be distributed
  1350.  * and used freely, without restriction.  If you make improvements or
  1351.  * enhancements, I would appreciate a copy.
  1352.  *
  1353.  * Duane H. Hesser    Teltone Corporation
  1354.  * ....uw-beaver!tikal!sysad
  1355.  * ....uw-beaver!tikal!dhh
  1356.  */
  1357.  
  1358. #include "extern.h"
  1359. #ifdef DEBUG
  1360. #include <stdio.h>
  1361. #endif
  1362.  
  1363.  
  1364. main(argc,argv)
  1365. int argc;
  1366. char **argv;
  1367. {
  1368.     extern void onintr();
  1369.     extern int read_stream();
  1370.     struct inbuf src;
  1371.     int files = 0;
  1372.     double atof();
  1373. #ifndef QUICKPLOT
  1374.     char *user, *host, *actfile;
  1375. #endif
  1376.  
  1377.     Name = argv[0];
  1378.     ++argv;
  1379. #ifdef DEBUG
  1380.     setbuf(stdout,(char *)0);
  1381. #endif
  1382. #ifndef QUICKPLOT
  1383.     if(strcmp(Name,"rlplot") == 0)
  1384.     {
  1385.         ++Rotate;
  1386.     }
  1387. #endif
  1388.  
  1389.  
  1390.     Eflag = 1;
  1391. #ifdef QUICKPLOT
  1392.     getsize((char *)0);                /* get the size of the terminal */
  1393. #else
  1394.     user = host = actfile = (char *)0;
  1395. #endif
  1396.     while(--argc) 
  1397.     {
  1398.         if(argv[0][0] == '-')
  1399.         {
  1400.             switch(argv[0][1])
  1401.             {
  1402. #ifdef QUICKPLOT
  1403.             case 'T':    /* size for a specific terminal                */
  1404.                 getsize(argv[1]);
  1405.                 --argc;
  1406.                 ++argv;
  1407.                 break;
  1408.             case 'c':    /* select plotting character                */
  1409.                 plotchar = *argv[1];
  1410.                 --argc;
  1411.                 ++argv;
  1412.                 break;
  1413. #endif
  1414.             case 'r':    /* rotate entire plot 90 degrees            */
  1415.                 ++Rotate;
  1416.                 break;
  1417.             case 'W':
  1418.                 maxcol = atoi(argv[1]);
  1419.                 --argc;
  1420.                 ++argv;
  1421.                 break;
  1422.             case 'H':
  1423.                 maxrow = atoi(argv[1]);
  1424.                 --argc;
  1425.                 ++argv;
  1426.                 break;
  1427.             case 'X':    /* move the whole plot horizontally            */
  1428. #ifdef QUICKPLOT
  1429.                 Xmargin = atof(argv[1]);                /* columns    */
  1430. #else
  1431.                 Xmargin = atof(argv[1]) * XPERINCH;        /* inches    */
  1432. #endif
  1433.                 --argc;
  1434.                 ++argv;
  1435.                 break;
  1436.             case 'Y':    /* move the whole plot vertically            */
  1437. #ifdef QUICKPLOT
  1438.                 Ymargin = atof(argv[1]);                /* rows        */
  1439. #else
  1440.                 Ymargin = atof(argv[1]) * YPERINCH;        /* inches    */
  1441. #endif
  1442.                 --argc;
  1443.                 ++argv;
  1444.                 break;
  1445.             case 's':    /* request x, y, or overall scale factors    */
  1446.                 if(argv[0][2] == '\0')
  1447.                     Scalfac = atof(argv[1]);
  1448.                 else if(argv[0][2] == 'x')
  1449.                     argxfac = atof(argv[1]);
  1450.                 else if(argv[0][2] == 'y')
  1451.                     argyfac = atof(argv[1]);
  1452.                 --argc;
  1453.                 ++argv;
  1454.                 break;
  1455.             case 'e':    /* force erase before each file is plotted    */
  1456.                 ++Eflag;
  1457.                 Nflag = 0;
  1458.                 break;
  1459.             case 'N':    /* suppress erasing                            */
  1460.                 ++Nflag;
  1461.                 Eflag = 0;
  1462.                 break;
  1463. #ifndef QUICKPLOT
  1464.             case 'x':    /* get width in pixels (from lpr)            */
  1465.                 maxcol = atoi(&argv[0][2]);
  1466.                 break;
  1467.             case 'y':    /* get hieght in pixels (from lpr)            */
  1468.                 maxrow = atoi(&argv[0][2]);
  1469.                 break;
  1470.             case 'n':    /* get user (from lpr) for accounting        */
  1471.                 user = argv[1];
  1472.                 ++argv;
  1473.                 --argc;
  1474.                 break;
  1475.             case 'h':    /* get host and accounting file (from lpr)    */
  1476.                 host = argv[1];
  1477.                 ++argv; --argc;
  1478.                 actfile = argv[2];
  1479.                 --argc; ++argv;
  1480.                 break;
  1481. #endif
  1482. #ifdef DEBUG
  1483.             case 'd':    /* debug                                    */
  1484.                 debug = atoi(argv[1]);
  1485.                 ++argv;
  1486.                 --argc;
  1487.                 break;
  1488. #endif
  1489.             case '\0':    /* read standard input here                    */
  1490.                 src.fd = 0;
  1491.                 src.nleft = 0;
  1492.                 src.eof = 0;
  1493.                 lplot(&src);
  1494.                 if(Plotdata && Eflag) output();
  1495.                 bufclose(&src);
  1496.                 break;
  1497.             default:
  1498.                 break;
  1499.             }
  1500.         }
  1501.         else        /* file argument                                */
  1502.         {
  1503.             if(bufopen(argv[0],&src) < 0) 
  1504.             {
  1505.                 char ebuf[64];
  1506.                 sprintf(ebuf,"%s: can't open input %s\n",Name,argv[0]);
  1507.                 write(2,ebuf,strlen(ebuf));
  1508.                 exit(1);
  1509.             }
  1510.             lplot(&src);
  1511.             if(Plotdata && Eflag) output();
  1512.             bufclose(&src);
  1513.             files++;
  1514.         }
  1515.         argv++;
  1516.     }
  1517.     Nflag = 0;
  1518.     if(files == 0)    /* no file arguments given; read stdin            */
  1519.     {
  1520.         src.fd = 0;
  1521.         src.nleft = 0;
  1522.         src.eof = 0;
  1523.         lplot(&src);
  1524.     }
  1525.     if(Plotdata) output();    /* force out anything that may be left    */
  1526. #ifndef QUICKPLOT
  1527.     if(actfile && *actfile && (access(actfile,02) == 0))
  1528.     {
  1529.         int fda = open(actfile,1);
  1530.         char abuf[32];
  1531.         if(fda < 0) exit(0);
  1532.         if(!user || !*user) user = "lplot";
  1533.         if(!host || !*host) host = "unknown";
  1534.         sprintf(abuf,"%7.2f\t%s:%s\n", (float)Npages, host, user);
  1535.         write(fda,abuf,strlen(abuf));
  1536.     }
  1537. #endif
  1538.     exit(0);
  1539. }
  1540.  
  1541. lplot(source)
  1542. struct inbuf *source;
  1543. {
  1544.     int got;
  1545.     /* This next is a hack to suppress an initial "erase" command,
  1546.      * (as "graph(1)" is so fond of issuing) before there is anything
  1547.      * to plot.  If there is plot data, the erase will force it out.
  1548.      * After the first page is printed, an erase will be honored
  1549.      * unconditionally (unless erasing is suppressed with '-N').
  1550.      */
  1551.     static int firstplot = 1;
  1552.  
  1553.     while( (got = read_stream(source)))
  1554.     {
  1555. #ifdef DEBUG
  1556.         if(debug & 2) printf("got=%ld,Plotdata=%d\n",got,Plotdata);
  1557. #endif
  1558.         /* got = -1 means no plot cmds except erase                    */
  1559.         if((got == -1) && !Nflag && !Plotdata)
  1560.         {
  1561.             if(!firstplot)
  1562.                 write(1,"\014",1);
  1563.             continue;
  1564.         }
  1565.         Plotdata++;                /* there is something to plot        */
  1566.         firstplot = 0;
  1567.         if(!Nflag && got < 0)    /* erase command received            */
  1568.             output();
  1569.     }
  1570. }
  1571.  
  1572. /* Send the plot data to stdout.  The data are processed by rows,
  1573.  * each of which is treated as a string.  We don't send nulls at
  1574.  * the end of the string, but we must fill in null bytes before
  1575.  * the last byte in the row which contains data.  For lplot, we
  1576.  * must set bit 6 ('\100') to make the byte valid for plotting;
  1577.  * for quickplot, null bytes need to be spaces.
  1578.  */
  1579. output()
  1580. {
  1581.     int y,len,maxc;
  1582.     char c;
  1583.     struct outbuf outbuf;
  1584.  
  1585.     outbuf.datalen = 0;
  1586.     outbuf.nextp = outbuf.buffer;
  1587.  
  1588. #ifdef QUICKPLOT
  1589.     maxc = maxcol;
  1590. #else
  1591.     maxc = (maxcol + 5)/6;
  1592. #endif
  1593. #ifdef DEBUG
  1594.     if(debug & 2) printf("output:maxc=%d\n",maxc);
  1595. #endif
  1596.  
  1597.     for(y = maxrow - 1; y >= 0; --y)
  1598.     {
  1599.         char *row = Row[y];
  1600.         char *end = &row[maxc];
  1601.  
  1602.         /* make sure the string is terminated                         */
  1603.         *end-- = '\0';
  1604.  
  1605.         /* find the last non-null byte in the row                    */
  1606.         while(!*end && (end >= row))    end--;
  1607.         len = end - row + 1;
  1608. #ifdef DEBUG
  1609.         if(debug & 4) printf("row[%d]=%d bytes\n",y,len);
  1610. #endif
  1611.  
  1612. #ifndef QUICKPLOT
  1613.         /* set bit 6 in all bytes to be transmitted                    */
  1614.         while(end >= row) *end-- |= BIT[6]; 
  1615.         Row[y][len++] = GRAPHICSCHAR;
  1616.         Row[y][len++] = '\n';
  1617.         Row[y][len] = '\0';
  1618. #else
  1619.         /* just send a space for quickplot                            */
  1620.         while(end >= row) if(!*end) *end-- = ' '; else --end;
  1621.         len = strlen(Row[y]);
  1622.         /* leave cursor lower right                                    */
  1623.         if(y)
  1624.         {
  1625.             strcat(Row[y],"\n");
  1626.             ++len;
  1627.         }
  1628. #endif
  1629.         bufwrite(Row[y],len,&outbuf);
  1630. #ifdef DEBUG
  1631.         if(debug & 4) buf_flush(&outbuf);
  1632. #endif
  1633.         bzero(Row[y],XARRAYSIZE);    /* clear the array for next plot */
  1634.     }
  1635.     Plotdata = 0;
  1636.     buf_flush(&outbuf);
  1637. #ifdef QUICKPLOT
  1638.     /* Pause after each plot unless output is redirected.
  1639.      * Read from the error channel because we might be reading
  1640.      * plot data from stdin.
  1641.      */
  1642.     if(isatty(1) && isatty(2)) read(2,&c,1);
  1643.     else write(1,"\n",1);
  1644. #else
  1645.     /* for accounting, one page per plot                            */
  1646.     Npages++;
  1647. #endif
  1648. }
  1649.  
  1650. #ifdef QUICKPLOT
  1651. /* get the size of the terminal from the environment                */
  1652. getsize(term)
  1653. char *term;
  1654. {
  1655.     char *terminal,termbuf[1024],*getenv();
  1656.     int cols,lines;
  1657.  
  1658.     /* set defaults                                                    */
  1659.     maxcol = cols = XDOTS;
  1660.     maxrow = lines = YDOTS;
  1661.  
  1662.     if(!term) terminal = getenv("TERM");
  1663.     else terminal = term;
  1664.  
  1665.     if((terminal)  && (tgetent(termbuf,terminal) == 1))
  1666.     {
  1667.         cols = tgetnum("co");
  1668.         if(cols > 0) maxcol = cols;
  1669.         lines = tgetnum("li");
  1670.         if(lines > 0) maxrow = lines;
  1671.         autowrap = tgetflag("am");
  1672.     }
  1673.     spacex = maxcol;
  1674.     spacey = maxrow;
  1675. }
  1676. #endif QUICKPLOT
  1677. SHAR_EOF
  1678. if test 7614 -ne "`wc -c < 'lplot.c'`"
  1679. then
  1680.     echo shar: error transmitting "'lplot.c'" '(should have been 7614 characters)'
  1681. fi
  1682. fi
  1683. echo shar: extracting "'read_stream.c'" '(3320 characters)'
  1684. if test -f 'read_stream.c'
  1685. then
  1686.     echo shar: will not over-write existing file "'read_stream.c'"
  1687. else
  1688. cat << \SHAR_EOF > 'read_stream.c'
  1689. /* :set tabstops=4                                                    */
  1690. static char *RCSid = "$Header: read_stream.c,v 1.1 86/04/20 16:16:49 sysad Exp $";
  1691.  
  1692. /*
  1693.  * $Log:    read_stream.c,v $
  1694.  * Revision 1.1  86/04/20  16:16:49  sysad
  1695.  * Initial distribution version
  1696.  * 
  1697.  * 
  1698.  */
  1699.  
  1700.  
  1701. /* It is the intent of the author that this software may be distributed
  1702.  * and used freely, without restriction.  If you make improvements or
  1703.  * enhancements, I would appreciate a copy.
  1704.  *
  1705.  * Duane H. Hesser    Teltone Corporation
  1706.  * ....uw-beaver!tikal!sysad
  1707.  * ....uw-beaver!tikal!dhh
  1708.  */
  1709.  
  1710. #include "defs.h"
  1711. #include "extern.h"
  1712.  
  1713. read_stream(source)
  1714. struct inbuf *source;
  1715. {
  1716.     char c;
  1717.     char string[256],ebuf[64];
  1718.     int len,got;
  1719.     short x0,y0,x1,y1,r;
  1720.     char getbyte();
  1721.     short getshort();
  1722.  
  1723.     got = 0;
  1724. #ifdef QUICKPLOT
  1725.     linemask = plotchar;
  1726. #endif
  1727.     while((c = getbyte(source)) && !eof(source))
  1728.     {
  1729.         ++got;
  1730.         switch(c)
  1731.         {
  1732.             case 'm':
  1733.                 curx = getshort(source);
  1734.                 cury = getshort(source);
  1735.                 move(curx,cury);
  1736.                 break;
  1737.             
  1738.             case 'n':
  1739.                 curx = getshort(source);
  1740.                 cury = getshort(source);
  1741.                 cont(curx,cury);
  1742.                 break;
  1743.             
  1744.             case 'p':
  1745.                 curx = getshort(source);
  1746.                 cury = getshort(source);
  1747.                 move(curx,cury);
  1748.                 point(curxdot,curydot);
  1749.                 break;
  1750.             
  1751.             case 'l':
  1752.                 x1 = getshort(source);
  1753.                 y1 = getshort(source);
  1754.                 curx = getshort(source);
  1755.                 cury = getshort(source);
  1756.                 line(x1,y1,curx,cury);
  1757.                 break;
  1758.             
  1759.             case 't':
  1760.                 len = getstr(source,string);
  1761.                 label(string,len);
  1762.                 break;
  1763.             
  1764.             case 'a':
  1765.                 curx = getshort(source);
  1766.                 cury = getshort(source);
  1767.                 x0 = getshort(source);
  1768.                 y0 = getshort(source);
  1769.                 x1 = getshort(source);
  1770.                 y1 = getshort(source);
  1771.                 arc(curx,cury,x0,y0,x1,y1);
  1772.                 /* The manual doesn't specify this, but it seems
  1773.                  * the most reasonable thing to do.
  1774.                  */
  1775.                 move(curx,cury);
  1776.                 break;
  1777.             
  1778.             case 'c':
  1779.                 x1 = getshort(source);
  1780.                 y1 = getshort(source);
  1781.                 r = getshort(source);
  1782.                 circle(x1,y1,r);
  1783.                 /* (x1,y1) becomes current point                    */
  1784.                 break;
  1785.             
  1786.             case 'e':
  1787.                 return(-got); /* negative got triggers erase        */
  1788.                 break;
  1789.             break;
  1790.             
  1791.             case 'f':
  1792.                 --got;
  1793.                 len = getstr(source,string);
  1794.                 if(!len) break;
  1795.  
  1796. #ifdef DEBUG
  1797.                 if(debug & 1) printf("linemask=%s",string);
  1798. #endif
  1799. #ifdef QUICKPLOT
  1800.                 if(strcmp(string,"solid") == 0)
  1801.                     linemask = plotchar;
  1802.                 else if(strcmp(string,"dotted") == 0)
  1803.                     linemask = '2';
  1804.                 else if(strcmp(string,"shortdashed") == 0)
  1805.                     linemask = '3';
  1806.                 else if(strcmp(string,"longdashed") == 0)
  1807.                     linemask = '4';
  1808.                 else if(strcmp(string,"dotdashed") == 0)
  1809.                     linemask = '5';
  1810.                 break;
  1811. #else
  1812.                 if(strcmp(string,"solid") == 0)
  1813.                     linemask = SOLID;
  1814.                 else if(strcmp(string,"dotted") == 0)
  1815.                     linemask = DOTTED;
  1816.                 else if(strcmp(string,"shortdashed") == 0)
  1817.                     linemask = SHORTDASHED;
  1818.                 else if(strcmp(string,"longdashed") == 0)
  1819.                     linemask = LONGDASHED;
  1820.                 else if(strcmp(string,"dotdashed") == 0)
  1821.                     linemask = DOTDASHED;
  1822.                 break;
  1823. #endif QUICKPLOT
  1824.             
  1825.             case 's':
  1826.                 --got;
  1827.                 x0 = getshort(source);
  1828.                 y0 = getshort(source);
  1829.                 x1 = getshort(source);
  1830.                 y1 = getshort(source);
  1831.                 space(x0,y0,x1,y1);
  1832.                 break;
  1833.             default:
  1834.                 --got;
  1835.                 sprintf(ebuf,"bad input data: cmd (0%o)\n",c);
  1836.                 write(2,ebuf,strlen(ebuf));
  1837.                 break;
  1838.         }
  1839.     }
  1840.     /* return the number of commands decoded                        */
  1841.     return(--got > 0 ? got : 0);
  1842. }
  1843.  
  1844. SHAR_EOF
  1845. if test 3320 -ne "`wc -c < 'read_stream.c'`"
  1846. then
  1847.     echo shar: error transmitting "'read_stream.c'" '(should have been 3320 characters)'
  1848. fi
  1849. fi
  1850. echo shar: extracting "'defs.h'" '(2516 characters)'
  1851. if test -f 'defs.h'
  1852. then
  1853.     echo shar: will not over-write existing file "'defs.h'"
  1854. else
  1855. cat << \SHAR_EOF > 'defs.h'
  1856. /* :set tabstop=4                                                    */
  1857. /*
  1858.  * $Header: defs.h,v 1.1 86/04/20 16:16:52 sysad Exp $
  1859.  */
  1860.  
  1861. /*
  1862.  * $Log:    defs.h,v $
  1863.  * Revision 1.1  86/04/20  16:16:52  sysad
  1864.  * Initial distribution version
  1865.  * 
  1866.  * 
  1867.  */
  1868.  
  1869.  
  1870. /* It is the intent of the author that this software may be distributed
  1871.  * and used freely, without restriction.  If you make improvements or
  1872.  * enhancements, I would appreciate a copy.
  1873.  *
  1874.  * Duane H. Hesser    Teltone Corporation
  1875.  * ....uw-beaver!tikal!sysad
  1876.  * ....uw-beaver!tikal!dhh
  1877.  */
  1878.  
  1879. #ifndef QUICKPLOT
  1880. #define    GRAPHICSCHAR    '\005'    /* puts printer in graphics mode    */
  1881. #define    XPERINCH    ((double)60.0)        /* horizontal dot density    */
  1882. #define    YPERINCH    ((double)72.0)        /* vertical dot density        */
  1883. #define    SPACEX    ((8 * XPERINCH) - 1)    /* dots for 8 inch plot area*/
  1884. #define    SPACEY    ((8 * YPERINCH)    - 1)    /* dots for 8 inch plot area*/
  1885. #define    XDOTS    792                /* maximum possible horizontal dots    */
  1886. /* we lose 12 dots vertically with the print head positioned for
  1887.  * printing on the first line in ascii mode
  1888.  */
  1889. #define    YDOTS    780                /* maximum possible vertical dots    */
  1890. #define    XBYTES    (XDOTS/6)        /* bytes needed for XDOTS            */
  1891. #define    MAXX    (XDOTS - 1)        /* maximum plottable x value        */
  1892. #define    MAXY    (YDOTS - 1)        /* maximum plottable y value        */
  1893. #else
  1894. #define    PLOTCHAR    'X'            /* use this char for plotting        */
  1895. #define    XPERINCH    ((double)10.0)        /* horizontal dot density    */
  1896. #define    YPERINCH    ((double)6.0)        /* vertical dot density        */
  1897. #define    SPACEX    ((8 * XPERINCH) - 1)    /* dots for 8 inch plot area*/
  1898. #define    SPACEY    ((8 * YPERINCH)    - 1)    /* dots for 8 inch plot area*/
  1899. #define    XDOTS    132                /* maximum possible horizontal dots    */
  1900. #define    YDOTS    66                /* maximum possible vertical dots    */
  1901. #define    XBYTES    (XDOTS)            /* horizontal dimension of array    */
  1902. #define    MAXX    (XDOTS - 1)        /* maximum plottable x value        */
  1903. #define    MAXY    (YDOTS - 1)        /* maximum plottable y value        */
  1904. #endif
  1905.  
  1906. /* Horizontal dimension of Row array.
  1907.  * Add 1 byte for a null, 1 for LF, 1 for graphics byte
  1908.  */
  1909. #define    XARRAYSIZE    (XBYTES + 3)
  1910.  
  1911. /* Linemode masks; used in make_line() for lplot                    */
  1912. #define    SOLID 0177777
  1913. #define    DOTTED 001
  1914. #define    SHORTDASHED 003
  1915. #define    DOTDASHED 013
  1916. #define    LONGDASHED 007
  1917.  
  1918. #ifndef QUICKPLOT
  1919. #define    mapx(x)    ((((double)x - lowx_space) * mapxfac) + Xmargin + 0.5)
  1920. #define    mapy(y)    ((((double)y - lowy_space) * mapyfac) + Ymargin + 0.5)
  1921. #define    plotbit(x,a)    (x & (1 << a))
  1922. #else
  1923. #define    mapx(x)    ((((double)x - lowx_space) * mapxfac) + Xmargin + 0.01)
  1924. #define    mapy(y)    ((((double)y - lowy_space) * mapyfac) + Ymargin + 0.01)
  1925. #endif
  1926. SHAR_EOF
  1927. if test 2516 -ne "`wc -c < 'defs.h'`"
  1928. then
  1929.     echo shar: error transmitting "'defs.h'" '(should have been 2516 characters)'
  1930. fi
  1931. fi
  1932. echo shar: extracting "'extern.h'" '(1193 characters)'
  1933. if test -f 'extern.h'
  1934. then
  1935.     echo shar: will not over-write existing file "'extern.h'"
  1936. else
  1937. cat << \SHAR_EOF > 'extern.h'
  1938. /* :set tabstop=4                                                    */
  1939. /*
  1940.  * $Header: extern.h,v 1.1 86/04/20 16:17:03 sysad Exp $
  1941.  */
  1942.  
  1943. /*
  1944.  * $Log:    extern.h,v $
  1945.  * Revision 1.1  86/04/20  16:17:03  sysad
  1946.  * Initial distribution version
  1947.  * 
  1948.  * 
  1949.  */
  1950.  
  1951.  
  1952. /* It is the intent of the author that this software may be distributed
  1953.  * and used freely, without restriction.  If you make improvements or
  1954.  * enhancements, I would appreciate a copy.
  1955.  *
  1956.  * Duane H. Hesser    Teltone Corporation
  1957.  * ....uw-beaver!tikal!sysad
  1958.  * ....uw-beaver!tikal!dhh
  1959.  */
  1960.  
  1961. #include "defs.h"
  1962. #include "io.h"
  1963. extern char Row[][XARRAYSIZE];
  1964. #ifndef QUICKPLOT
  1965. extern char BIT[];
  1966. #else
  1967. extern char plotchar;
  1968. extern int autowrap;
  1969. #endif
  1970.  
  1971. extern double spacex,spacey;
  1972. extern double xspace,yspace;
  1973. extern double lowx_space,highx_space,lowy_space,highy_space;
  1974. extern int maxx,maxy,maxrow,maxcol;
  1975.  
  1976. extern short curx,cury,curxdot,curydot;
  1977. extern double Scalfac,xfac,yfac,argxfac,argyfac;
  1978. extern double mapxfac,mapyfac;
  1979. extern double Xmargin,Ymargin;
  1980.  
  1981. extern int Plotdata;
  1982. extern int Eflag;
  1983. extern int Nflag;
  1984. extern int linemask;
  1985.  
  1986. extern char *Name;
  1987. #ifdef DEBUG
  1988. extern int debug;
  1989. #endif
  1990. extern int Rotate;
  1991.  
  1992. #ifndef QUICKPLOT
  1993. extern int Npages;
  1994. extern char table[][10];
  1995. #endif
  1996. SHAR_EOF
  1997. if test 1193 -ne "`wc -c < 'extern.h'`"
  1998. then
  1999.     echo shar: error transmitting "'extern.h'" '(should have been 1193 characters)'
  2000. fi
  2001. fi
  2002. echo shar: extracting "'io.h'" '(701 characters)'
  2003. if test -f 'io.h'
  2004. then
  2005.     echo shar: will not over-write existing file "'io.h'"
  2006. else
  2007. cat << \SHAR_EOF > 'io.h'
  2008. /* :set tabstop=4                                                    */
  2009. /*
  2010.  * $Header: io.h,v 1.1 86/04/20 16:17:06 sysad Exp $
  2011.  */
  2012.  
  2013. /*
  2014.  * $Log:    io.h,v $
  2015.  * Revision 1.1  86/04/20  16:17:06  sysad
  2016.  * Initial distribution version
  2017.  * 
  2018.  * 
  2019.  */
  2020.  
  2021.  
  2022. /* It is the intent of the author that this software may be distributed
  2023.  * and used freely, without restriction.  If you make improvements or
  2024.  * enhancements, I would appreciate a copy.
  2025.  *
  2026.  * Duane H. Hesser    Teltone Corporation
  2027.  * ....uw-beaver!tikal!sysad
  2028.  * ....uw-beaver!tikal!dhh
  2029.  */
  2030.  
  2031. #define    INBUFSIZE    2048
  2032. #define    OUTBUFSIZE    2048
  2033.  
  2034. struct inbuf
  2035. {
  2036.     int fd;
  2037.     int nleft;
  2038.     int eof;
  2039.     char *nextp;
  2040.     char buff[INBUFSIZE];
  2041. };
  2042.  
  2043. struct outbuf {
  2044.     int datalen;
  2045.     char *nextp;
  2046.     char buffer[OUTBUFSIZE];
  2047. };
  2048. SHAR_EOF
  2049. if test 701 -ne "`wc -c < 'io.h'`"
  2050. then
  2051.     echo shar: error transmitting "'io.h'" '(should have been 701 characters)'
  2052. fi
  2053. fi
  2054. if test ! -d 'testprogs.d'
  2055. then
  2056.     echo shar: creating directory "'testprogs.d'"
  2057.     mkdir 'testprogs.d'
  2058. fi
  2059. echo shar: extracting "'testprogs.d/Makefile'" '(497 characters)'
  2060. if test -f 'testprogs.d/Makefile'
  2061. then
  2062.     echo shar: will not over-write existing file "'testprogs.d/Makefile'"
  2063. else
  2064. cat << \SHAR_EOF > 'testprogs.d/Makefile'
  2065. all:    box circle lineh linev lined dlined arc
  2066.  
  2067. arc:    arc.c
  2068.     cc -o arc arc.c -lplot -lm
  2069.  
  2070. box:    box.c
  2071.     cc -o box box.c -lplot
  2072.  
  2073. circle:    circle.c
  2074.     cc -o circle circle.c -lplot -lm
  2075.  
  2076. lineh:    lineh.c
  2077.     cc -o lineh lineh.c -lplot
  2078.  
  2079. linev:    linev.c
  2080.     cc -o linev linev.c -lplot
  2081.  
  2082. lined:    lined.c
  2083.     cc -o lined lined.c -lplot
  2084.  
  2085. dlined:    dlined.c
  2086.     cc -o dlined dlined.c -lplot
  2087.  
  2088. graphplot:
  2089.     grplot
  2090.     @echo 'type "quickplot tmpload" or "lplot tmpload | lpr -v"'
  2091. clean:
  2092.     rm -f box circle lineh linev lined tmpload dlined arc
  2093. SHAR_EOF
  2094. if test 497 -ne "`wc -c < 'testprogs.d/Makefile'`"
  2095. then
  2096.     echo shar: error transmitting "'testprogs.d/Makefile'" '(should have been 497 characters)'
  2097. fi
  2098. fi
  2099. echo shar: extracting "'testprogs.d/lined.c'" '(270 characters)'
  2100. if test -f 'testprogs.d/lined.c'
  2101. then
  2102.     echo shar: will not over-write existing file "'testprogs.d/lined.c'"
  2103. else
  2104. cat << \SHAR_EOF > 'testprogs.d/lined.c'
  2105. /* diagaonal line lower left to upper right */
  2106. main(argc,argv)
  2107. int argc;
  2108. char **argv;
  2109. {
  2110.     int x0,x1,y0,y1;
  2111.  
  2112.     x0 = 0;
  2113.     y0 = 0;
  2114.     x1 = 2000;
  2115.     y1 = 2000;
  2116.     space(x0,y0,2000,2000);
  2117.     move(x0,y0);
  2118.     label("+");
  2119.     move(x1,y1);
  2120.     label("+");
  2121.     line(x0,y0,x1,y1);
  2122.     erase();
  2123.     exit(0);
  2124. }
  2125. SHAR_EOF
  2126. if test 270 -ne "`wc -c < 'testprogs.d/lined.c'`"
  2127. then
  2128.     echo shar: error transmitting "'testprogs.d/lined.c'" '(should have been 270 characters)'
  2129. fi
  2130. fi
  2131. echo shar: extracting "'testprogs.d/linev.c'" '(273 characters)'
  2132. if test -f 'testprogs.d/linev.c'
  2133. then
  2134.     echo shar: will not over-write existing file "'testprogs.d/linev.c'"
  2135. else
  2136. cat << \SHAR_EOF > 'testprogs.d/linev.c'
  2137. /* vertical line along left side of plot space */
  2138. main(argc,argv)
  2139. int argc;
  2140. char **argv;
  2141. {
  2142.     int x0,x1,y0,y1;
  2143.  
  2144.     x0 = 0;
  2145.     y0 = 0;
  2146.     x1 = 2000;
  2147.     y1 = 2000;
  2148.     space(x0,y0,2000,2000);
  2149.     move(x0,y0);
  2150.     label("+");
  2151.     move(x0,y1);
  2152.     label("+");
  2153.     line(x0,y0,x0,y1);
  2154.     erase();
  2155.     exit(0);
  2156. }
  2157. SHAR_EOF
  2158. if test 273 -ne "`wc -c < 'testprogs.d/linev.c'`"
  2159. then
  2160.     echo shar: error transmitting "'testprogs.d/linev.c'" '(should have been 273 characters)'
  2161. fi
  2162. fi
  2163. echo shar: extracting "'testprogs.d/box.c'" '(373 characters)'
  2164. if test -f 'testprogs.d/box.c'
  2165. then
  2166.     echo shar: will not over-write existing file "'testprogs.d/box.c'"
  2167. else
  2168. cat << \SHAR_EOF > 'testprogs.d/box.c'
  2169. /* box surrounding plot space--no args */
  2170.  
  2171. main(argc,argv)
  2172. int argc;
  2173. char **argv;
  2174. {
  2175.     int x0,x1,y0,y1;
  2176.  
  2177.     x0 = 0;
  2178.     y0 = 0;
  2179.     x1 = 2000;
  2180.     y1 = 2000;
  2181.     space(x0,y0,x1,y1);
  2182.  
  2183.     move(x0,y0);
  2184.     label("1");
  2185.     move(x0,y1);
  2186.     label("2");
  2187.     move(x1,y1);
  2188.     label("3");
  2189.     move(x1,y0);
  2190.     label("4");
  2191.     move(x0,y0);
  2192.     line(x0,y0,x0,y1);
  2193.     cont(x1,y1);
  2194.     cont(x1,y0);
  2195.     cont(x0,y0);
  2196.     erase();
  2197.     exit(0);
  2198. }
  2199. SHAR_EOF
  2200. if test 373 -ne "`wc -c < 'testprogs.d/box.c'`"
  2201. then
  2202.     echo shar: error transmitting "'testprogs.d/box.c'" '(should have been 373 characters)'
  2203. fi
  2204. fi
  2205. echo shar: extracting "'testprogs.d/dlined.c'" '(475 characters)'
  2206. if test -f 'testprogs.d/dlined.c'
  2207. then
  2208.     echo shar: will not over-write existing file "'testprogs.d/dlined.c'"
  2209. else
  2210. cat << \SHAR_EOF > 'testprogs.d/dlined.c'
  2211. /* with no args, gives dotted diagaonal line. one optional argument is
  2212.  * permitted to change line mode.  permitted modes are:
  2213.  *    solid
  2214.  *    dotted
  2215.  *  shortdashed
  2216.  *  longdashed
  2217.  *  dotdashed
  2218.  */
  2219. main(argc,argv)
  2220. int argc;
  2221. char **argv;
  2222. {
  2223.     int x0,x1,y0,y1;
  2224.  
  2225.     x0 = 0;
  2226.     y0 = 0;
  2227.     x1 = 2000;
  2228.     y1 = 2000;
  2229.     space(x0,y0,2000,2000);
  2230.     if(argc > 1) linemod(argv[1]);
  2231.     else linemod("dotted");
  2232.     move(x0,y0);
  2233.     label("+");
  2234.     move(x1,y1);
  2235.     label("+");
  2236.     line(x0,y0,x1,y1);
  2237.     erase();
  2238.     exit(0);
  2239. }
  2240. SHAR_EOF
  2241. if test 475 -ne "`wc -c < 'testprogs.d/dlined.c'`"
  2242. then
  2243.     echo shar: error transmitting "'testprogs.d/dlined.c'" '(should have been 475 characters)'
  2244. fi
  2245. fi
  2246. echo shar: extracting "'testprogs.d/lineh.c'" '(273 characters)'
  2247. if test -f 'testprogs.d/lineh.c'
  2248. then
  2249.     echo shar: will not over-write existing file "'testprogs.d/lineh.c'"
  2250. else
  2251. cat << \SHAR_EOF > 'testprogs.d/lineh.c'
  2252. /* hoizontal line across bottom of plot space */
  2253.  
  2254. main(argc,argv)
  2255. int argc;
  2256. char **argv;
  2257. {
  2258.     int x0,x1,y0,y1;
  2259.  
  2260.     x0 = 0;
  2261.     y0 = 0;
  2262.     x1 = 2000;
  2263.     y1 = 2000;
  2264.     space(x0,y0,2000,2000);
  2265.     move(x0,y0);
  2266.     label("+");
  2267.     move(x1,y0);
  2268.     label("+");
  2269.     line(x0,y0,x1,y0);
  2270.     erase();
  2271.     exit(0);
  2272. }
  2273. SHAR_EOF
  2274. if test 273 -ne "`wc -c < 'testprogs.d/lineh.c'`"
  2275. then
  2276.     echo shar: error transmitting "'testprogs.d/lineh.c'" '(should have been 273 characters)'
  2277. fi
  2278. fi
  2279. echo shar: extracting "'testprogs.d/arc.c'" '(541 characters)'
  2280. if test -f 'testprogs.d/arc.c'
  2281. then
  2282.     echo shar: will not over-write existing file "'testprogs.d/arc.c'"
  2283. else
  2284. cat << \SHAR_EOF > 'testprogs.d/arc.c'
  2285. /* arc centered on x,y starting at x0,y0, thru x1,y1    */
  2286.  
  2287. #include <math.h>
  2288. main(argc,argv)
  2289. int argc;
  2290. char **argv;
  2291. {
  2292.     int x,y,x0,y0,x1,y1;
  2293.  
  2294.     if(argc == 1)
  2295.     {
  2296.         x = 1000;
  2297.         y = 1000;
  2298.         x0 = 2000;
  2299.         y0 = 1000;
  2300.         x1 = 700;
  2301.         y1 = 700;
  2302.     }
  2303.     else if(argc != 7)
  2304.     {
  2305.         printf("usage: arc x y x0 y0 x1 y1\n\t(range 0-2000)\n");
  2306.         exit(1);
  2307.     }
  2308.     else
  2309.     {
  2310.         x = atoi(argv[1]);
  2311.         y = atoi(argv[2]);
  2312.         x0 = atoi(argv[3]);
  2313.         y0 = atoi(argv[4]);
  2314.         x1 = atoi(argv[5]);
  2315.         y1 = atoi(argv[6]);
  2316.     }
  2317.     space(0,0,2000,2000);
  2318.     arc(x,y,x0,y0,x1,y1);
  2319.     erase();
  2320.     exit(0);
  2321. }
  2322. SHAR_EOF
  2323. if test 541 -ne "`wc -c < 'testprogs.d/arc.c'`"
  2324. then
  2325.     echo shar: error transmitting "'testprogs.d/arc.c'" '(should have been 541 characters)'
  2326. fi
  2327. fi
  2328. echo shar: extracting "'testprogs.d/circle.c'" '(213 characters)'
  2329. if test -f 'testprogs.d/circle.c'
  2330. then
  2331.     echo shar: will not over-write existing file "'testprogs.d/circle.c'"
  2332. else
  2333. cat << \SHAR_EOF > 'testprogs.d/circle.c'
  2334. /* circle inscribed on plot space--no args */
  2335. #include <math.h>
  2336. main(argc,argv)
  2337. int argc;
  2338. char **argv;
  2339. {
  2340.     int x,y,r;
  2341.  
  2342.     x = 1000;
  2343.     y = 1000;
  2344.     r = 1000;
  2345.     space(0,0,2000,2000);
  2346.     circle(x,y,r);
  2347.     erase();
  2348.     exit(0);
  2349. }
  2350.  
  2351. SHAR_EOF
  2352. if test 213 -ne "`wc -c < 'testprogs.d/circle.c'`"
  2353. then
  2354.     echo shar: error transmitting "'testprogs.d/circle.c'" '(should have been 213 characters)'
  2355. fi
  2356. fi
  2357. echo shar: done with directory "'testprogs.d'"
  2358. exit 0
  2359. #    End of shell archive
  2360.